#ifndef __WIZ_BNF_ACTOR_OPERATORS_HPP__SHANHAOBO_19800429__
#define __WIZ_BNF_ACTOR_OPERATORS_HPP__SHANHAOBO_19800429__

#include "../../Base/WizBase.hpp"

#include "./WizBNFActorComposite.hpp"

#include "./WizBNFActorOperatorsRank.hpp"
#include "./WizBNFActorOperatorsBinary.hpp"
#include "./WizBNFActorOperatorsUnary.hpp"

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

/// Binary
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::PlusAssign, BaseT, ElementT>::tType
operator+=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::PlusAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::MinusAssign, BaseT, ElementT>::tType
operator-=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::MinusAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::TimesAssign, BaseT, ElementT>::tType
operator*=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::TimesAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::DivideAssign, BaseT, ElementT>::tType
operator/=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::DivideAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ModAssign, BaseT, ElementT>::tType
operator%=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ModAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::AndAssign, BaseT, ElementT>::tType
operator&=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::AndAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::OrAssign, BaseT, ElementT>::tType
operator|=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::OrAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::XorAssign, BaseT, ElementT>::tType
operator<<=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::XorAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftLeftAssign, BaseT, ElementT>::tType
operator^=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftLeftAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftRightAssign, BaseT, ElementT>::tType
operator>>=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftRightAssign, BaseT, ElementT>::Construct(Arg1, Arg2);
}

/// Binary +
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Plus, BaseT, ElementT>::tType
operator+(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Plus, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Plus, ElementT, BaseT>::tType
operator+(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Plus, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Plus, BaseT0, BaseT1>::tType
operator+(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Plus, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary -
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Minus, BaseT, ElementT>::tType
operator-(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Minus, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Minus, ElementT, BaseT>::tType
operator-(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Minus, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Minus, BaseT0, BaseT1>::tType
operator-(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Minus, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary *
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Times, BaseT, ElementT>::tType
operator*(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Times, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Times, ElementT, BaseT>::tType
operator*(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Times, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Times, BaseT0, BaseT1>::tType
operator*(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Times, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary /
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Divide, BaseT, ElementT>::tType
operator/(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Divide, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Divide, ElementT, BaseT>::tType
operator/(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Divide, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Divide, BaseT0, BaseT1>::tType
operator/(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Divide, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary %
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Mod, BaseT, ElementT>::tType
operator%(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Mod, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Mod, ElementT, BaseT>::tType
operator%(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Mod, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Mod, BaseT0, BaseT1>::tType
operator%(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Mod, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary &
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::And, BaseT, ElementT>::tType
operator&(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::And, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::And, ElementT, BaseT>::tType
operator&(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::And, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::And, BaseT0, BaseT1>::tType
operator&(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::And, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary |
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Or, BaseT, ElementT>::tType
operator|(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Or, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Or, ElementT, BaseT>::tType
operator|(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Or, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Or, BaseT0, BaseT1>::tType
operator|(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Or, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary ^
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Xor, BaseT, ElementT>::tType
operator^(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Xor, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Xor, ElementT, BaseT>::tType
operator^(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Xor, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Xor, BaseT0, BaseT1>::tType
operator^(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Xor, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary <<
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftLeft, BaseT, ElementT>::tType
operator<<(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftLeft, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::ShiftLeft, ElementT, BaseT>::tType
operator<<(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::ShiftLeft, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::ShiftLeft, BaseT0, BaseT1>::tType
operator<<(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::ShiftLeft, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary >>
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftRight, BaseT, ElementT>::tType
operator>>(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::ShiftRight, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::ShiftRight, ElementT, BaseT>::tType
operator>>(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::ShiftRight, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::ShiftRight, BaseT0, BaseT1>::tType
operator>>(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::ShiftRight, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary ==
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Equal, BaseT, ElementT>::tType
operator==(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Equal, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Equal, ElementT, BaseT>::tType
operator==(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Equal, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Equal, BaseT0, BaseT1>::tType
operator==(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Equal, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary !=
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::NotEqual, BaseT, ElementT>::tType
operator!=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::NotEqual, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::NotEqual, ElementT, BaseT>::tType
operator!=(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::NotEqual, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::NotEqual, BaseT0, BaseT1>::tType
operator!=(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::NotEqual, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary <
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Less, BaseT, ElementT>::tType
operator<(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Less, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Less, ElementT, BaseT>::tType
operator<(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Less, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Less, BaseT0, BaseT1>::tType
operator<(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Less, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary <=
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::LessEqual, BaseT, ElementT>::tType
operator<=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::LessEqual, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::LessEqual, ElementT, BaseT>::tType
operator<=(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::LessEqual, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::LessEqual, BaseT0, BaseT1>::tType
operator<=(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::LessEqual, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary >
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Greater, BaseT, ElementT>::tType
operator>(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::Greater, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Greater, ElementT, BaseT>::tType
operator>(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::Greater, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Greater, BaseT0, BaseT1>::tType
operator>(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::Greater, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary >=
template <typename BaseT, typename ElementT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::GreaterEqual, BaseT, ElementT>::tType
operator>=(::Wiz::BNF::Actor::Type<BaseT> const& Arg1, ElementT const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary1<::Wiz::BNF::Actor::Operators::Binary::GreaterEqual, BaseT, ElementT>::Construct(Arg1, Arg2);
}

template <typename ElementT, typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::GreaterEqual, ElementT, BaseT>::tType
operator>=(ElementT const& Arg1, ::Wiz::BNF::Actor::Type<BaseT> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary2<::Wiz::BNF::Actor::Operators::Binary::GreaterEqual, ElementT, BaseT>::Construct(Arg1, Arg2);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::GreaterEqual, BaseT0, BaseT1>::tType
operator>=(::Wiz::BNF::Actor::Type<BaseT0> const& Arg1, ::Wiz::BNF::Actor::Type<BaseT1> const& Arg2)
{
    return ::Wiz::BNF::Composite::MakeBinary3<::Wiz::BNF::Actor::Operators::Binary::GreaterEqual, BaseT0, BaseT1>::Construct(Arg1, Arg2);
}

/// Binary &&
template <typename BaseT, typename T1>
WIZ_INLINE ::Wiz::BNF::Actor::Type<::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT>, typename ::Wiz::BNF::Actor::As<T1>::tType>>
operator&&(::Wiz::BNF::Actor::Type<BaseT> const& _0, T1 const& _1)
{
    return ::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT>, typename ::Wiz::BNF::Actor::As<T1>::tType>
        (_0, ::Wiz::BNF::Actor::As<T1>::Convert(_1));
}

template <typename T0, typename BaseT>
WIZ_INLINE ::Wiz::BNF::Actor::Type<::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<typename ::Wiz::BNF::Actor::As<T0>::tType, ::Wiz::BNF::Actor::Type<BaseT>>>
operator&&(T0 const& _0, ::Wiz::BNF::Actor::Type<BaseT> const& _1)
{
    return ::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<typename ::Wiz::BNF::Actor::As<T0>::tType, ::Wiz::BNF::Actor::Type<BaseT>>
        (::Wiz::BNF::Actor::As<T1>::Convert(_0), _1);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE ::Wiz::BNF::Actor::Type<::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT0>, ::Wiz::BNF::Actor::Type<BaseT1>>>
operator&&(::Wiz::BNF::Actor::Type<BaseT0> const& _0, ::Wiz::BNF::Actor::Type<BaseT1> const& _1)
{
    return ::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT0>, ::Wiz::BNF::Actor::Type<BaseT1>>
        (_0, _1);
}

/// Binary ||
template <typename BaseT, typename T1>
WIZ_INLINE ::Wiz::BNF::Actor::Type<::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT>, typename ::Wiz::BNF::Actor::As<T1>::tType>>
operator||(::Wiz::BNF::Actor::Type<BaseT> const& _0, T1 const& _1)
{
    return ::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT>, typename ::Wiz::BNF::Actor::As<T1>::tType>
        (_0, ::Wiz::BNF::Actor::As<T1>::Convert(_1));
}

template <typename T0, typename BaseT>
WIZ_INLINE ::Wiz::BNF::Actor::Type<::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<typename ::Wiz::BNF::Actor::As<T0>::tType, ::Wiz::BNF::Actor::Type<BaseT>>>
operator||(T0 const& _0, ::Wiz::BNF::Actor::Type<BaseT> const& _1)
{
    return ::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<typename ::Wiz::BNF::Actor::As<T0>::tType, ::Wiz::BNF::Actor::Type<BaseT>>
        (::Wiz::BNF::Actor::As<T1>::Convert(_0), _1);
}

template <typename BaseT0, typename BaseT1>
WIZ_INLINE ::Wiz::BNF::Actor::Type<::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT0>, ::Wiz::BNF::Actor::Type<BaseT1>>>
operator||(::Wiz::BNF::Actor::Type<BaseT0> const& _0, ::Wiz::BNF::Actor::Type<BaseT1> const& _1)
{
    return ::Wiz::BNF::Actor::Operators::Binary::LogicalAnd<::Wiz::BNF::Actor::Type<BaseT0>, ::Wiz::BNF::Actor::Type<BaseT1>>
        (_0, _1);
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Negative, BaseT>::tType
operator-(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Negative, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Positive, BaseT>::tType
operator+(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Positive, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::LogicalNot, BaseT>::tType
operator!(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::LogicalNot, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Invert, BaseT>::tType
operator~(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Invert, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Reference, BaseT>::tType
operator&(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::Reference, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::DeReference, BaseT>::tType
operator*(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::DeReference, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PreIncr, BaseT>::tType
operator++(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PreIncr, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PreDecr, BaseT>::tType
operator--(::Wiz::BNF::Actor::Type<BaseT> const& _0)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PreDecr, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PostIncr, BaseT>::tType
operator++(::Wiz::BNF::Actor::Type<BaseT> const& _0, int)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PostIncr, BaseT>::Construct(_0);
}

template <typename BaseT>
WIZ_INLINE typename ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PostDecr, BaseT>::tType
operator--(::Wiz::BNF::Actor::Type<BaseT> const& _0, int)
{
    return ::Wiz::BNF::Composite::MakeUnary<::Wiz::BNF::Actor::Operators::Unary::PostDecr, BaseT>::Construct(_0);
}

#endif /*__WIZ_BNF_ACTOR_OPERATORS_HPP__SHANHAOBO_19800429__*/
